#include "InterfaceGraphique.h"



void gestion_lancer_MainWindow(Utilisateur * u)
{
    /* On charge l'agenda de l'utilisateur */
    Agenda a;
    agendaInitialiser(&a);
    char nomagenda[30];
    strcpy(nomagenda,"agenda");
    strcat(nomagenda ,utilisateurGetNom(u));
    agendaCharger(&a, nomagenda);

    /* Pointeurs sur Widgets */
    GtkWidget * pMainWindow=NULL;
    GtkWidget * pEntry1;
    GtkWidget * pEntry2;
    GtkWidget * pEntry3;
    GtkWidget * pButton1;
    GtkWidget * pButton2;
    GtkWidget * pButton3;
    GtkWidget * pButton4;
    GtkWidget * pButton5;
    GtkWidget * pTable;
    GtkWidget * pLabel1;
    GtkWidget * pLabel2;
    GtkWidget * pLabel3;
    GtkWidget * pLabel4;
    GtkWidget * pLabel5;
    GtkWidget * pLabel6;
    GtkWidget * pMenuBar=NULL;
    GtkWidget * pMenu=NULL;
    GtkWidget * pMenuItem=NULL;
    GtkWidget * pVBox1;
    GtkWidget * pVBox2;
    GtkWidget * pVBox3;
    GtkWidget * pVBox4;
    GtkWidget * pVBox5;
    GtkWidget * pVBox6;
    GtkWidget * pFrame;
    GtkWidget * pFrame1;
    GtkWidget * pFrame2;
    GtkWidget * pFrame3;
    GtkWidget * pFrame4;
    GtkWidget * pFrame5;
    GtkWidget * pFrame6;
    GtkWidget * pFrame7;
    GtkWidget * text_view;
    GtkWidget * pToolBar;
    GList * pList = NULL;
    GtkWidget *scrollbar;
    GtkWidget *scrollbar1;
    GtkWidget *scrollbar2;
    GtkWidget *scrollbar3;

    /*Creation de la fenêtre principale*/
    pMainWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pMainWindow), "RSACrypt");
    gtk_window_set_default_size(GTK_WINDOW(pMainWindow), 1000,1000);
    gtk_window_set_position(GTK_WINDOW(pMainWindow), GTK_WIN_POS_MOUSE);
    gtk_container_set_border_width(GTK_CONTAINER(pMainWindow), 5);

    /* Creation de la table */
    pTable = gtk_table_new(12,4, TRUE);

    /*On met des barre de défilement pour les petits écrans*/
    scrollbar=gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollbar), pTable);

    /* Insertion de la table dans la fenêtre principale */
    gtk_container_add(GTK_CONTAINER(pMainWindow), GTK_WIDGET(scrollbar));

    /* Création des Boutons */
    pButton1=gtk_button_new_with_mnemonic("_Crypter");
    pButton2=gtk_button_new_with_mnemonic("_Decrypter");
    pButton3=gtk_button_new_with_label("Chercher un fichier à décrypter");
    pButton4=gtk_button_new_with_label("Chercher un fichier à crypter");
    pButton5=gtk_button_new_with_label("Donner un nom au fichier de sortie");

    /* Création des Boxs verticales */
    pVBox1=gtk_vbox_new(TRUE, 2);
    pVBox2=gtk_vbox_new(TRUE, 2);
    pVBox3=gtk_vbox_new(TRUE, 2);
    pVBox4=gtk_vbox_new(TRUE, 2);
    pVBox5=gtk_vbox_new(TRUE, 2);
    pVBox6=gtk_vbox_new(TRUE, 2);

    /* Insetion des Boutons dans la Box1 */
    gtk_box_pack_start(GTK_BOX(pVBox1), pButton1, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox1), pButton2, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox1), pButton3, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox1), pButton4, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox1), pButton5, TRUE, TRUE, 0);

    /* On insère la Box1 dans le pFrame7 */
    pFrame7 = gtk_frame_new("");
    gtk_container_add(GTK_CONTAINER(pFrame7), pVBox1);

    /* Création des labels */
    pLabel1=gtk_label_new("");
    scrollbar2=gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollbar2), pLabel1);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbar2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    pLabel2=gtk_label_new("");
    scrollbar3=gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollbar3), pLabel2);
    pLabel3=gtk_label_new("Nom du contact");
    pLabel4=gtk_label_new("Nom du fichier texte à décrypter");
    pLabel5=gtk_label_new("Entrez votre texte à crypter");
    pLabel6=gtk_label_new("Nom du fichier contenant le texte crypté");

    /* Création d'une zone de texte à une ligne pour le nom du contact*/
    pEntry1=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry1), TRUE);
    gtk_entry_set_text(GTK_ENTRY(pEntry1), "nom du contact");

    /* Création d'une zone de texte à une ligne pour le nom du fichier*/
    pEntry2=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry2), TRUE);
    gtk_entry_set_text(GTK_ENTRY(pEntry2), "nom du fichier de cryptage à charger");

    /* Création d'une zone de texte à une ligne pour le nom du fichier*/
    pEntry3=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry3), TRUE);
    gtk_entry_set_text(GTK_ENTRY(pEntry3), "nom du fichier de cryptage de sorti");

    /* Création d'une zone de texte multilignes et ajout d'une barre de défilement*/
    text_view=gtk_text_view_new();
    scrollbar1=gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add(GTK_CONTAINER(scrollbar1),text_view);

    /* Insertion des boxs 2 à 5 dans la box6 */
    pFrame = gtk_frame_new("");
    gtk_container_add(GTK_CONTAINER(pFrame), pVBox6);
    pFrame1 = gtk_frame_new("Destinataire");
    gtk_container_add(GTK_CONTAINER(pFrame1), pVBox2);
    gtk_box_pack_start(GTK_BOX(pVBox6), pFrame1, TRUE, TRUE, 0);
    pFrame2 = gtk_frame_new("Decryptage");
    gtk_container_add(GTK_CONTAINER(pFrame2), pVBox3);
    gtk_box_pack_start(GTK_BOX(pVBox6), pFrame2, TRUE, TRUE, 0);
    pFrame3 = gtk_frame_new("Cryptage");
    gtk_container_add(GTK_CONTAINER(pFrame3), pVBox4);
    gtk_box_pack_start(GTK_BOX(pVBox6), pFrame3, TRUE, TRUE, 0);
    pFrame4 = gtk_frame_new("Zone d'Affichage");
    gtk_container_add(GTK_CONTAINER(pFrame4), pVBox5);
    gtk_box_pack_start(GTK_BOX(pVBox6), pFrame4, TRUE, TRUE, 0);

    /* Insertion du pLabel2 dans pFrame5 */
    pFrame5 = gtk_frame_new("Zone de notification");
    gtk_container_add(GTK_CONTAINER(pFrame5), scrollbar3);

    /* Insertion des elts dans les différentes boxs */
    gtk_box_pack_start(GTK_BOX(pVBox2), pLabel3, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox2), pEntry1, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox2), pLabel6, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox2), pEntry3, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox3), pLabel4, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox3), pEntry2, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox4), pLabel5, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox4), scrollbar1, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pVBox5), scrollbar2, TRUE, TRUE, 0);

    /* On remplit la liste pour les fonctions CallBack */
    pList=g_list_append(pList, (GtkWidget*)pLabel1);
    pList=g_list_append(pList, (GtkWidget*)pEntry1);
    pList=g_list_append(pList, (GtkWidget*)pLabel2);
    pList=g_list_append(pList, (GtkWidget*)pMainWindow);
    pList=g_list_append(pList, (Utilisateur*)u);
    pList=g_list_append(pList, (GtkWidget*)text_view);
    pList=g_list_append(pList, (Agenda*)&a);
    pList=g_list_append(pList, (GtkWidget*)pEntry2);
    pList=g_list_append(pList, (char*)&etat_identification);
    pList=g_list_append(pList, (char *)nomagenda);
    pList=g_list_append(pList, (GtkWidget*)pEntry3);
    pList=g_list_append(pList, (Utilisateur**)&u);

    /* Création de la barre d'outils */
    pToolBar=gtk_toolbar_new();
    gtk_toolbar_append_item(GTK_TOOLBAR(pToolBar), "Selectionner un contact", "choisir le destinataire de votre message",  NULL, NULL, G_CALLBACK(gestion_selectionner_contact), (GList*)pList);
    gtk_toolbar_append_item(GTK_TOOLBAR(pToolBar), "Ajouter un contact", "Ajoute un contact à votre agenda, vous devez connaitre sa clef publique",  NULL, NULL, G_CALLBACK(gestion_ajouter_contact), (GList*)pList);
    gtk_toolbar_append_item(GTK_TOOLBAR(pToolBar), "Supprimer un contact", "Enlève un contact de votre agenda",  NULL, NULL, G_CALLBACK(gestion_supprimer_contact), (GList*)pList);
    gtk_toolbar_append_item(GTK_TOOLBAR(pToolBar), "Changer d'utilisateur", "retour à la fenêtre d'identification",  NULL, NULL, G_CALLBACK(gestion_deconnecter), (GList*)pList);
    gtk_toolbar_append_item(GTK_TOOLBAR(pToolBar), "Afficher ma clef publique", "utiliser cette option afin de transmettre votre clef publique à vos contact",  NULL, NULL, G_CALLBACK(gestion_afficher_clef), (GList*)pList);

    /* Insertion de la barre d'outil dans pFrame6 */
    pFrame6 = gtk_frame_new("");
    gtk_container_add(GTK_CONTAINER(pFrame6), pToolBar);

    /* Creation de la Barre de menu (GtkMenuBar) */
    pMenuBar = gtk_menu_bar_new();

    /* Création du premier menu */
    pMenu = gtk_menu_new();

    /* Création et insertion des differents gtkMenuItems dans le GtkMenu */
    pMenuItem = gtk_menu_item_new_with_label("Afficher clef");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_afficher_clef), pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Changer d'utilisateur");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_deconnecter), pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Quitter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_quitter_MainWindow), NULL);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    /* On crée le GtkMenuItem qui ira dans le GtkMenuBar */
    pMenuItem = gtk_menu_item_new_with_label("Fichier");

    /* On lie ce GtkMenuItem au GtkMenu */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);

    /* On l'insère dans le GtkMenuBar */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /* Création du deuxieme menu */
    pMenu = gtk_menu_new();

    /* Création et insertion des differents gtkMenuItems dans le GtkMenu */
    pMenuItem = gtk_menu_item_new_with_label("Ajouter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_ajouter_contact), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Supprimer");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_supprimer_contact), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Selectionner");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_selectionner_contact), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    /* On crée le GtkMenuItem qui ira dans le GtkMenuBar */
    pMenuItem = gtk_menu_item_new_with_label("Contacts");

    /* On lie ce GtkMenuItem au GtkMenu */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);

    /* On l'insère dans le GtkMenuBar */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /* Création du troisieme menu */
    pMenu = gtk_menu_new();

    /* Création et insertion des differents gtkMenuItems dans le GtkMenu */
    pMenuItem = gtk_menu_item_new_with_label("Crypter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_crypter), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Chercher un fichier à crypter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_file_selection_cryptage), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Donner un nom au fichier de sortie");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_file_selection_sortie), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    /* On crée le GtkMenuItem qui ira dans le GtkMenuBar */
    pMenuItem = gtk_menu_item_new_with_label("Crypter");

    /* On lie ce GtkMenuItem au GtkMenu */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);

    /* On l'insère dans le GtkMenuBar */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /* Création du quatrième menu */
    pMenu = gtk_menu_new();

    /* Création et insertion des differents gtkMenuItems dans le GtkMenu */
    pMenuItem = gtk_menu_item_new_with_label("Decrypter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_decrypter), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    pMenuItem = gtk_menu_item_new_with_label("Chercher un fichier à decrypter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_file_selection_decryptage), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    /* On crée le GtkMenuItem qui ira dans le GtkMenuBar */
    pMenuItem = gtk_menu_item_new_with_label("Decrypter");

    /* On lie ce GtkMenuItem au GtkMenu */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);

    /* On l'insère dans le GtkMenuBar */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /* Création du cinquième menu */
    pMenu = gtk_menu_new();

    /* Création et insertion des differents gtkMenuItems dans le GtkMenu */
    pMenuItem = gtk_menu_item_new_with_label("Aide");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(gestion_information), (GList *)pList);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);

    /* On crée le GtkMenuItem qui ira dans le GtkMenuBar */
    pMenuItem = gtk_menu_item_new_with_label("Information");

    /* On lie ce GtkMenuItem au GtkMenu */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);

    /* On l'insère dans le GtkMenuBar */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);

    /* Insertion des éléments dans la table */
    gtk_table_attach_defaults(GTK_TABLE(pTable), pMenuBar,0,4,0,1);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pFrame6,0,4,1,2);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pFrame7,0,1,2,11);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pFrame,1,4,2,11);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pFrame5,0,4,11,12);

    /* Gestion des évènements */
    g_signal_connect(G_OBJECT(pMainWindow), "destroy", G_CALLBACK(gestion_quitter_MainWindow), NULL);
    g_signal_connect(G_OBJECT(pButton1), "clicked", G_CALLBACK(gestion_crypter), (GList*)pList);
    g_signal_connect(G_OBJECT(pButton2), "clicked", G_CALLBACK(gestion_decrypter), (GList*)pList);
    g_signal_connect(G_OBJECT(pButton3), "clicked", G_CALLBACK(gestion_file_selection_decryptage), pList);
    g_signal_connect(G_OBJECT(pButton4), "clicked", G_CALLBACK(gestion_file_selection_cryptage), pList);
    g_signal_connect(G_OBJECT(pButton5), "clicked", G_CALLBACK(gestion_file_selection_sortie), pList);

    /* Affichage */
    gtk_widget_show_all(pMainWindow);

    /* Boucle évènementielle */
    gtk_main();

    /* On libère la mémoire allouée dynamiquement */
    agendaLiberer(&a);
    g_list_free(pList);
}


void gestion_quitter_MainWindow(GtkWidget* widget, gpointer data)
{
    etat_identification=2;
    gtk_main_quit();
}


void gestion_crypter(GtkWidget * pButton1, GList * data)
{
    /* Variables */
//    GtkWidget * pLabel;
    GtkWidget * pLabel2;
    GtkWidget * pEntry;
    GtkWidget * pEntry2;
    GtkWidget * text_view;
    GtkTextBuffer* text_buffer=0;
    GtkTextIter start;
    GtkTextIter end;
    gchar* buf=0;

    /* on récupère les pointeurs sur le Label1 et sur la zone de texte, et sur l'Entry */
//    pLabel = g_list_nth_data(data, 0);
    pEntry = (GtkWidget *)g_list_nth_data(data, 1);
    pEntry2 = (GtkWidget *)g_list_nth_data(data, 10);
    pLabel2 = (GtkWidget *)g_list_nth_data(data, 2);
    text_view = (GtkWidget *)g_list_nth_data(data, 5);

    /* On récupère le texte saisie par l'utilisateur dans la zone de texte */
    const gchar * nom;
    nom = gtk_entry_get_text(GTK_ENTRY(pEntry));

    /* On cree un contact pour pouvoir récuperer sa clef publique à partir du nom du pEntry */
    Contact * c;
    c=agendaRechercher((Agenda *)g_list_nth_data(data, 6), (char *)nom);
    if (c == NULL)
    {
        gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel2), "Ce contact n'existe pas");
    }
    else
    {
        //On recupere le buffer
        text_buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));

        //On recupere l'origine du buffer
        gtk_text_buffer_get_start_iter(text_buffer,&start);

        //On recupere la fin du buffer
        gtk_text_buffer_get_end_iter(text_buffer,&end);

        //On copie le contenu du buffer dans une variable
        buf=gtk_text_buffer_get_text(text_buffer,&start, &end,TRUE);

        /* On crypte le texte */
        mpz_t *resultat;
        resultat=Crypter(buf, contactGetClefPublique(c));
        CrypterSauver(resultat, (char *)gtk_entry_get_text(GTK_ENTRY(pEntry2)), strlen(buf));

        /* On met le texte crypter dans le label */
        //gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel), buf);

        /* On précise que le texte est bien crypté et enregistré */
        gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel2), "Texte crypé et enregistré");

        /* On libère la mémoire allouée dynamiquement */
        CrypterLiberer(resultat, strlen(buf));
        g_free(buf);
    }
}


void gestion_decrypter(GtkWidget * pButton1, GList * data)
{
    /* Variables */
    GtkWidget * pLabel;
    GtkWidget * pLabel2;
    GtkWidget * pEntry;
//    GtkWidget * text_view;
//    GtkTextBuffer* text_buffer=0;
//    GtkTextIter start;
//    GtkTextIter end;
//    gchar* buf=0;
    Utilisateur * u1;

    /* on récupère les pointeurs sur le Label1 et sur la zone de texte */
    pLabel = (GtkWidget *)g_list_nth_data(data, 0);
    pEntry = (GtkWidget *)g_list_nth_data(data, 7);
    pLabel2 = (GtkWidget *)g_list_nth_data(data, 2);
//  text_view = g_list_nth_data(data, 11);
    u1 = (Utilisateur *)g_list_nth_data(data, 4);


    /* On récupère le texte saisie par l'utilisateur dans la zone de texte */
    const gchar * text;
    text = gtk_entry_get_text(GTK_ENTRY(pEntry));

    //On recupere le buffer
//    text_buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));
    //On recupere l'origine du buffer
//    gtk_text_buffer_get_start_iter(text_buffer,&start);
    //On recupere la fin du buffer
//    gtk_text_buffer_get_end_iter(text_buffer,&end);

    //On copie le contenu du buffer dans une variable
//    buf=gtk_text_buffer_get_text(text_buffer,&start, &end,TRUE);

    /* On charge le fichier contenant le texte crypté en gérant les erreurs */
    int taille;
    char * resultat;
//    char * resultat_UTF8;
    mpz_t * cryptage;
    cryptage=DecypterCharger(text, &taille);

    if (cryptage==NULL)
    {
        gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel2), "Nom de fichier à charger incorrect");
    }
    else
    {
        /* On decrypte le texte */
        resultat=Decrypter(cryptage, utilisateurGetClefPrivee(u1), taille);

        /* On converti le texte en UTF8 pour les accents */
//        resultat_UTF8=g_locale_to_utf8(resultat, -1, NULL, NULL, NULL);

        /* On met le texte décrypter dans le label */
        gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel), resultat);
        gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel2), "Texte décrypté avec succes");
    }
    free(resultat);
    CrypterLiberer(cryptage, taille);
}


void gestion_ajouter_contact(GtkWidget * widget, GList * data)
{
    /* Variables */
    GtkWidget* pBoite;
    GtkWidget* pLabel1;
    GtkWidget* pLabel2;
    GtkWidget* pLabel3;
    GtkWidget* pLabel4;
    GtkWidget* pLabel5;
    GtkWidget* pEntry1;
    GtkWidget* pEntry2;
    GtkWidget* pEntry3;
    GtkWidget* pEntry4;
    GtkWidget* pEntry5;

    /* On récupère les données de l'utilisateur */
    Utilisateur * u;
    u = (Utilisateur *)g_list_nth_data(data, 4);

    /* On récupère sont agenda */
    Agenda *a1;
    a1=(Agenda *)g_list_nth_data(data, 6);

    /* On déclare et initialise un contact, les grand entier sont pour sa clef publique */
    Contact * c;
    mpz_t n1;
    mpz_t c1;
    contactInitialiser(&c);
    mpz_init(n1);
    mpz_init(c1);

    /* On met dans nomagenda le nom de l'agenda de l'utilisateur courant */
    char nomagenda[30];
    strcpy(nomagenda,"agenda");
    strcat(nomagenda ,utilisateurGetNom(u));

    /* Creation de la boite de dialogue */
    /* 1 bouton Valider */
    /* 1 bouton Annuler */
    pBoite = gtk_dialog_new_with_buttons("Ajouter contact",
        GTK_WINDOW(g_list_nth_data(data, 3)),
        GTK_DIALOG_MODAL,
        GTK_STOCK_OK,GTK_RESPONSE_OK,
        GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
        NULL);

    /* Création des labels */
    pLabel1=gtk_label_new("Nom:");
    pLabel2=gtk_label_new("Prenom:");
    pLabel3=gtk_label_new("mail");
    pLabel4=gtk_label_new("1er champ clef publique");
    pLabel5=gtk_label_new("2eme champ clef publique");

    /* Creation des zones de saisie */
    pEntry1=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry1), TRUE);

    pEntry2=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry2), TRUE);

    pEntry3=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry3), TRUE);

    pEntry4=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry4), TRUE);

    pEntry5=gtk_entry_new();
    gtk_entry_set_visibility(GTK_ENTRY(pEntry5), TRUE);

    /* Insertion de la zone de saisie dans la boite de dialogue */
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pLabel1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry1, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pLabel2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry2, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pLabel3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry3, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pLabel4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry4, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pLabel5, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry5, TRUE, FALSE, 0);

    /* Affichage des elements de la boite de dialogue */
    gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox);

    /* On lance la boite de dialogue et on recupere la reponse */
    switch (gtk_dialog_run(GTK_DIALOG(pBoite)))
    {
        /* L' utilisateur valide */
        case GTK_RESPONSE_OK:
            contactSetNom(c, (char *)gtk_entry_get_text(GTK_ENTRY(pEntry1)));
            contactSetPrenom(c, (char *)gtk_entry_get_text(GTK_ENTRY(pEntry2)));
            contactSetMail(c, (char *)gtk_entry_get_text(GTK_ENTRY(pEntry3)));
            mpz_set_str(n1, (char *)gtk_entry_get_text(GTK_ENTRY(pEntry4)),10);
            mpz_set_str(c1, (char *)gtk_entry_get_text(GTK_ENTRY(pEntry5)),10);
            contactSetClefPublique(c, n1, c1);
            agendaAjouter(a1, c);
            agendaSauver(a1, nomagenda);
            gtk_label_set_text(GTK_LABEL(g_list_nth_data(data, 2)), "Contact ajouté !");
            break;

        /* L' utilisateur annule */
        case GTK_RESPONSE_CANCEL:
        case GTK_RESPONSE_NONE:
        default:
            gtk_label_set_text(GTK_LABEL(g_list_nth_data(data, 2)), "Vous n'avez rien saisi !");
            break;
    }

    /* Destruction de la boite de dialogue */
    gtk_widget_destroy(pBoite);
    mpz_clear(n1);
    mpz_clear(c1);
}


void gestion_file_selection_decryptage(GtkWidget* widget, GList * data)
{
    /* Variables */
    GtkWidget *selection;
    GtkWidget *pEntry2;
    GList * pList = NULL;

    /* On récupère le pEntry2 du main pour lui mettre le chemin du fichier */
    pEntry2=(GtkWidget *)g_list_nth_data(data, 7);

    /* On crée et on affiche la fenêtre de selection de fichier */
    selection = gtk_file_selection_new( g_locale_to_utf8( "Sélectionnez un fichier", -1, NULL, NULL, NULL) );
    gtk_widget_show(selection);

    /* On remplit la liste pour la fonction recupérer_chemin */
    pList=g_list_append(pList, (GtkWidget*)selection);
    pList=g_list_append(pList, (GtkWidget*)pEntry2);

    //On interdit l'utilisation des autres fenetres.
    gtk_window_set_modal(GTK_WINDOW(selection), TRUE);

    /* Gestion des évènements */
    g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(selection)->ok_button), "clicked", G_CALLBACK(gestion_recuperer_chemin_decryptage), (GList *)pList );
    g_signal_connect_swapped(G_OBJECT(GTK_FILE_SELECTION(selection)->cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), selection);

    /* On libère la/les liste(s) */
    //g_list_free(pList);
}


void gestion_recuperer_chemin_decryptage(GtkWidget *widget, GList * data)
{
    /* Variables */
    const gchar* chemin;
    GtkWidget *dialog;
    GtkWidget *file_selection;
    GtkWidget* pEntry2;

    /* on récupere les elements de la liste */
    file_selection=(GtkWidget *)g_list_nth_data(data, 0);
    pEntry2=(GtkWidget *)g_list_nth_data(data, 1);

    /* On récupère le chemin choisi par l'utilisateur */
    chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION (file_selection) );

    /* On met chemin dans pEntry2 */
    gtk_entry_set_text(GTK_ENTRY(pEntry2), chemin);

    /* On crée et on affiche la boite de dialogue */
    dialog = gtk_message_dialog_new(GTK_WINDOW(file_selection), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Vous avez choisi :\n%s", chemin);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
    gtk_widget_destroy(file_selection);

    /* On libère la/les liste(s) */
    g_list_free(data);
}


void gestion_file_selection_cryptage(GtkWidget* widget, GList * data)
{
    /* Variables */
    GtkWidget *selection;
    GtkWidget *text_view;
    GList * pList = NULL;

    /* On récupèere le pEntry2 du main pour lui mettre le chemin du fichier */
    text_view=(GtkWidget *)g_list_nth_data(data, 5);

    /* On ouvre la boite de selection d'un fichier */
    selection = gtk_file_selection_new(g_locale_to_utf8( "Sélectionnez un fichier", -1, NULL, NULL, NULL));
    gtk_widget_show(selection);

    /* On remplit la liste pour la fonction recupérer_chemin */
    pList=g_list_append(pList, (GtkWidget*)selection);
    pList=g_list_append(pList, (GtkWidget*)text_view);

    //On interdit l'utilisation des autres fenetres.
    gtk_window_set_modal(GTK_WINDOW(selection), TRUE);

    /* Gestion des évènements */
    g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(selection)->ok_button), "clicked", G_CALLBACK(gestion_recuperer_chemin_cryptage), (GList *)pList );
    g_signal_connect_swapped(G_OBJECT(GTK_FILE_SELECTION(selection)->cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), selection);

    /* On libère la/les liste(s) */
    //g_list_free(pList);
}


void gestion_recuperer_chemin_cryptage(GtkWidget *widget, GList * data)
{
    /* Variables */
    const gchar* chemin;
    GtkWidget *file_selection;
    GtkWidget* text_view;
    GtkTextBuffer *buffer;
    GtkTextIter start;
    GtkTextIter end;
    FILE *fichier;
    gchar lecture[1024];

    /* on récupere les elements de la liste */
    file_selection=(GtkWidget *)g_list_nth_data(data, 0);
    text_view=(GtkWidget *)g_list_nth_data(data, 1);

    /* On récupère le pointeur sur les données du text_view */
    buffer=gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_view));

    /* On récupère le chemin du fichier par l'utilisateur et on ouvre le fichier */
    chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION(file_selection) );
    fichier = fopen(chemin,"rwt");
    if(fichier == NULL)
    {
        GtkWidget *dialog;
        dialog = gtk_message_dialog_new(GTK_WINDOW(file_selection), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Impossible d'ouvrir le fichier : \n%s", g_locale_to_utf8(chemin, -1, NULL, NULL, NULL));
        gtk_dialog_run(GTK_DIALOG(dialog));
        gtk_widget_destroy(dialog);
        gtk_widget_destroy(file_selection);
        return;
    }

    /* On libère la mémoire allouée pour le text_view est ses widgets  */
    gtk_widget_destroy(file_selection);
    gtk_text_buffer_get_start_iter(buffer,&start);
    gtk_text_buffer_get_end_iter(buffer,&end);
    gtk_text_buffer_delete(buffer, &start, &end);

    /* On met le texte du fichier dans le text_view  */
    while(fgets(lecture, 1024, fichier))
    {
        gtk_text_buffer_get_end_iter(buffer,&end);
        gtk_text_buffer_insert(buffer, &end, g_locale_to_utf8(lecture, -1, NULL, NULL, NULL), -1);
    }
    fclose(fichier);

    /* On libère la/les liste(s) */
    g_list_free(data);
}


void gestion_file_selection_sortie(GtkWidget* widget, GList * data)
{
    /* Variables */
    GtkWidget *selection;
    GtkWidget *pEntry3;
    GList * pList = NULL;

    /* On récupère le pEntry2 du main pour lui mettre le chemin du fichier */
    pEntry3=(GtkWidget *)g_list_nth_data(data, 10);

    /* On crée et on affiche la fenêtre de selection de fichier */
    selection = gtk_file_selection_new( g_locale_to_utf8( "Sélectionnez un fichier", -1, NULL, NULL, NULL) );
    gtk_widget_show(selection);

    /* On remplit la liste pour la fonction recupérer_chemin */
    pList=g_list_append(pList, (GtkWidget*)selection);
    pList=g_list_append(pList, (GtkWidget*)pEntry3);

    //On interdit l'utilisation des autres fenetres.
    gtk_window_set_modal(GTK_WINDOW(selection), TRUE);

    /* gestion des évènements */
    g_signal_connect(G_OBJECT(GTK_FILE_SELECTION(selection)->ok_button), "clicked", G_CALLBACK(gestion_recuperer_chemin_sortie), (GList *)pList );
    g_signal_connect_swapped(G_OBJECT(GTK_FILE_SELECTION(selection)->cancel_button), "clicked", G_CALLBACK(gtk_widget_destroy), selection);

    /* On libère la/les liste(s) */
    //g_list_free(pList);
}


void gestion_recuperer_chemin_sortie(GtkWidget *widget, GList * data)
{
    const gchar* chemin;
    GtkWidget *dialog;
    GtkWidget *file_selection;
    GtkWidget* pEntry3;

    /* on récupere les elements de la liste */
    file_selection=(GtkWidget *)g_list_nth_data(data, 0);
    pEntry3=(GtkWidget *)g_list_nth_data(data, 1);

    chemin = gtk_file_selection_get_filename(GTK_FILE_SELECTION (file_selection) );

    /* On met chemin dans pEntry2 */
    gtk_entry_set_text(GTK_ENTRY(pEntry3), chemin);

    /* On crée et on affiche la boite de dialogue */
    dialog = gtk_message_dialog_new(GTK_WINDOW(file_selection), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, "Vous avez choisi :\n%s", chemin);
    gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
    gtk_widget_destroy(file_selection);

    /* On libère la/les liste(s) */
    g_list_free(data);
}


void gestion_deconnecter(GtkWidget * widget, GList * data)
{
//    printf("est rentré dans changer d'utilisateur \n");

    /* On récupère l'adresse du pointeur sur l'utilisateur courant afin de le libérer */
    Utilisateur ** u1;
    u1=(Utilisateur **)g_list_nth_data(data, 11);

//    printf("voici *u1 dans gestion_deconnecter: %p \n", *u1);

    utilisateurLiberer(*u1);
    *u1=NULL;

//    printf("voici *u1 dans gestion_deconnecter: %p \n", *u1);
//    printf("voici la valeur de etat_identification dans gestion_deconnecter : %d \n", etat_identification);

    /* On détruit la fenêtre principale de l'utilisateur courant */
    gtk_widget_destroy((GtkWidget *)g_list_nth_data(data, 3));

    /* On met la variable global etat_identification à 0 afin de relancer la fenêtre d'identification */
    etat_identification=0;

//    printf("voici la valeur de etat_identification dans gestion_deconnecter : %d \n", etat_identification);
}


void gestion_selectionner_contact(GtkWidget* widget, GList * data)
{
    /* Variables */
    Agenda *pAgenda = (Agenda*)g_list_nth_data(data,6);
    GtkWidget * pWindow=NULL;
    GtkWidget * scrollbar;
    GtkWidget * pButton[agendaTaille(pAgenda)];
    GtkWidget * pLabel[agendaTaille(pAgenda)];
    GtkWidget * pLabel2[agendaTaille(pAgenda)];
    GtkWidget * pLabel3[agendaTaille(pAgenda)];
    GtkWidget * pVBox;
    GList *pList[agendaTaille(pAgenda)];
    char * nom;
    char * prenom;
    char * mail;
    int i;

    /*Creation de la fenêtre principale*/
    pWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Selectionner un contact");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 300,400);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_MOUSE);
    gtk_container_set_border_width(GTK_CONTAINER(pWindow), 5);

    /* On crée la barre de défilement et on l'ajoute à la fenetre */
    scrollbar = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add(GTK_CONTAINER(pWindow),scrollbar);

    /* On crée la boite verticale */
    pVBox=gtk_vbox_new(TRUE, 2);

    /* On l'ajoute à la fenetre */
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollbar), pVBox);

    /* On supprime la barre de défilement horizontale */
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbar), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);

    for(i=0; i<agendaTaille(pAgenda); i++)
    {
        pList[i]=NULL;
        pList[i]=g_list_append(pList[i], (GtkWidget*)pWindow);
        pList[i]=g_list_append(pList[i], (GtkWidget*)g_list_nth_data(data, 1));


        nom=contactGetNom(agendaGetContact(pAgenda,i));
        prenom=contactGetPrenom(agendaGetContact(pAgenda,i));
        mail=contactGetMail(agendaGetContact(pAgenda,i));
        //printf( "voici le nom de l'utilisateur: %s \n", nom);
        pLabel[i]=gtk_label_new(nom);
        pLabel2[i]=gtk_label_new(prenom);
        pLabel3[i]=gtk_label_new(mail);
        pButton[i]=gtk_button_new_with_label("Selectionner");
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel[i], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel2[i], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel3[i], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pButton[i], TRUE, TRUE, 0);

        /* si le bouton est enfoncé on le connect à la fonction callBack avec le nom du contact correspondant */
        /* On ajoute à la liste le nom du contact selectionné */
        pList[i]=g_list_append(pList[i], (char *)nom);

        /* Gestion des évènements */
        g_signal_connect(G_OBJECT(pButton[i]), "clicked", G_CALLBACK(gestion_ajouter_nom_contact), (GList*)pList[i]);
    }

    /* Gestion des évènements */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(pWindow);
    gtk_main();

    /* On libère la/les liste(s) */
    for (i=0; i<agendaTaille(pAgenda); i++)
    {
        g_list_free(pList[i]);
    }
    /* On libère l'agenda */
//    agendaLiberer(pAgenda);
}


void gestion_ajouter_nom_contact(GtkWidget * widget, GList * data)
{
    gtk_entry_set_text(GTK_ENTRY((GtkWidget *)g_list_nth_data(data, 1)), (gchar *)g_list_nth_data(data,2));
    gtk_widget_destroy((GtkWidget *)g_list_nth_data(data,0));
}


void gestion_supprimer_contact(GtkWidget* widget, GList * data)
{
    /* Variables */
    Agenda *pAgenda = (Agenda*)g_list_nth_data(data,6);
    char * nomagenda = (char *)g_list_nth_data(data, 9);
    GtkWidget * pWindow=NULL;
    GtkWidget * scrollbar;
    GtkWidget * pButton[agendaTaille(pAgenda)];
    GtkWidget * pLabel[agendaTaille(pAgenda)];
    GtkWidget * pVBox;
    GList *pList[agendaTaille(pAgenda)];
    char * nom;
    int i;

    /*Creation de la fenêtre principale*/
    pWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Selectionner un contact");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 300, 400);
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_MOUSE);
    gtk_container_set_border_width(GTK_CONTAINER(pWindow), 5);

    /* On crée la barre de défilement et on l'ajoute à la fenetre */
    scrollbar = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add(GTK_CONTAINER(pWindow),scrollbar);

    /* On crée la boite verticale */
    pVBox=gtk_vbox_new(TRUE, 2);

    /* On l'ajoute à la fenetre */
    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollbar), pVBox);

    /* On supprime la barre de défilement horizontale */
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollbar), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);


    for(i=0; i<agendaTaille(pAgenda); i++)
    {
        /* On crée une liste spécifique à chaque bouton */
        pList[i]=NULL;
        pList[i]=g_list_append(pList[i], (GtkWidget*)pWindow);
        pList[i]=g_list_append(pList[i], (GtkWidget*)g_list_nth_data(data, 0));
        pList[i]=g_list_append(pList[i], (Agenda *)pAgenda);
        pList[i]=g_list_append(pList[i], (char *)nomagenda);

        nom=contactGetNom(agendaGetContact(pAgenda,i));
//        printf( "voici le nom de l'utilisateur: %s \n", nom);
        pLabel[i]=gtk_label_new(nom);
        pButton[i]=gtk_button_new_with_label("Selectionner");
        gtk_box_pack_start(GTK_BOX(pVBox), pLabel[i], TRUE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox), pButton[i], TRUE, TRUE, 0);

        /* si le bouton est enfoncé on le connect à la fonction callBack avec le nom du contact correspondant */
        /* On ajoute à la liste le nom du contact selectionné */
        pList[i]=g_list_append(pList[i], (char *)nom);

        /* Gestion des évènements */
        g_signal_connect(G_OBJECT(pButton[i]), "clicked", G_CALLBACK(gestion_supprimer_nom_contact), (GList*)pList[i]);
    }

    /* Gestion des évènements */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);

    /* Affichage et boucle évènementielle */
    gtk_widget_show_all(pWindow);
    gtk_main();

    /* On libère la/les liste(s) */
    for (i=0; i<agendaTaille(pAgenda); i++)
    {
        g_list_free(pList[i]);
    }
    /* On libère l'agenda */
//    agendaLiberer(pAgenda);
}


void gestion_supprimer_nom_contact(GtkWidget * widget, GList * data)
{
    gtk_label_set_text(GTK_LABEL((g_list_nth_data(data, 1))), "contact supprimé");

    /* On récupère l'agenda et le nom du contact à supprimé et on le supprime */
    agendaSupprimer((Agenda *)g_list_nth_data(data, 2), (char *)g_list_nth_data(data, 4));
    agendaSauver((Agenda *)g_list_nth_data(data, 2), (char *)g_list_nth_data(data, 3) );
    gtk_widget_destroy((GtkWidget *)g_list_nth_data(data,0));
}


void gestion_afficher_clef(GtkWidget* widget, GList * data)
{
    Utilisateur * u;
    GtkWidget * pLabel;
    /* à modifier */
    char clefpublique[2000];
    u=(Utilisateur *)g_list_nth_data(data, 4);
    pLabel= (GtkWidget *)g_list_nth_data(data, 2);
    gmp_sprintf(clefpublique, "Voici votre clef publique: (%Zd , %Zd) ", ClefPubliqueGetc(utilisateurGetClefPublique(u)), ClefPubliqueGetn(utilisateurGetClefPublique(u)));
    gtk_label_set_label(GTK_LABEL((GtkWidget*)pLabel), clefpublique);
}


void gestion_information(GtkWidget * widget, GList * data)
{
    GtkWidget *pAbout;
    gchar *information = (gchar *)"RSACrypt est une application de cryptage texte utilisant des clefs asymétriques. L'utilisateur dispose d'un agenda avec les clefs publiques de ses contacts, il peut alors écrire du texte et le chiffrer en fonction de son destinataire. L'application représente à la fois les parties « client » et « serveur » ainsi l'utilisateur peut aussi décrypter un texte chiffré avec sa clef publique. L'application permet de gérer plusieurs utilisateurs ayant chacun une clef privée différente." ;
    gchar *utilisation1 = (gchar *)"Une fois identifié, vous pouver : " ;
    gchar *utilisation2 = (gchar *)"1°- Gérer vos contacts (ajouter, supprimer, rechercher)." ;
    gchar *utilisation3 = (gchar *)"2°- Taper un texte dans la zones de texte dédiée, ou charger un fichier texte enregistré sur votre" ;
    gchar *utilisation4 = (gchar *)"3°- Selectionner le contact auquel vous souhaiter envoyer le texte crypté." ;
    gchar *utilisation5 = (gchar *)"4°- Crypter le texte en fonction de ce contact, seul lui pourra déchiffrer votre message." ;
    gchar *utilisation6 = (gchar *)"5°- Charger un message crypté pour vous (ce sont des fichiers textes avec beaucoup de lignes de chiffres)." ;
    gchar *utilisation7 = (gchar *)"6°- Décrypter ce message seulement s'il a été crypté pour vous." ;
    gchar *utilisation8 = (gchar *)"7°- Afficher votre clef publique afin de la transmettre à vos contact." ;

    /* Creation de la boite de message */
    /* Type : Information -> GTK_MESSAGE_INFO */
    /* Bouton : 1 OK -> GTK_BUTTONS_OK */
    pAbout = gtk_message_dialog_new (GTK_WINDOW(g_list_nth_data(data, 3)),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_INFO,
        GTK_BUTTONS_OK,
        "%s \n\n %s \n %s \n %s \n %s \n %s \n %s \n %s \n %s \n",
        information, utilisation1, utilisation2, utilisation3, utilisation4, utilisation5, utilisation6, utilisation7, utilisation8);

    /* Affichage de la boite de message */
    gtk_dialog_run(GTK_DIALOG(pAbout));

    /* Destruction de la boite de message */
    gtk_widget_destroy(pAbout);
}
